package com.lwl.blue.commont.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * UUID版本化工具类
 * 用于管理订单的历史版本，通过UUID v5命名空间生成版本化UUID
 * 
 * @author group3_pzj
 * @version V1.0
 */
public class UUIDVersionUtils {

    /**
     * 根据原UUID和版本号生成版本化UUID
     * 使用UUID v5基于原UUID和版本号生成确定性的版本化UUID
     * 
     * @param originalUUID 原订单UUID
     * @param version 版本号（如：V1, V2, V3...）
     * @return 版本化UUID
     */
    public static String generateVersionedUUID(String originalUUID, String version) {
        if (originalUUID == null || originalUUID.trim().isEmpty()) {
            throw new IllegalArgumentException("原UUID不能为空");
        }
        if (version == null || version.trim().isEmpty()) {
            throw new IllegalArgumentException("版本号不能为空");
        }
        try {
            // 使用原UUID作为命名空间
            UUID namespace = UUID.fromString(originalUUID);
            // 生成版本化UUID（确定性的，可逆） 唯一输出
            UUID versionedUUID = UUID.nameUUIDFromBytes(
                (namespace.toString() + "|" + version).getBytes()
            );
            return versionedUUID.toString();
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("无效的UUID格式: " + originalUUID, e);
        }
    }

    /**
     * 生成下一个版本号
     * 从V1开始，依次递增：V1 -> V2 -> V3 -> ...
     * 
     * @param currentVersion 当前版本号
     * @return 下一个版本号
     */
    public static String generateNextVersion(String currentVersion) {
        if (currentVersion == null || currentVersion.trim().isEmpty()) {
            return "V1";
        }
        
        // 提取版本号数字部分
        String versionStr = currentVersion.trim().toUpperCase();
        if (!versionStr.startsWith("V")) {
            return "V1";
        }
        
        try {
            int versionNum = Integer.parseInt(versionStr.substring(1));
            return "V" + (versionNum + 1);
        } catch (NumberFormatException e) {
            return "V1";
        }
    }

    /**
     * 获取指定UUID的所有历史版本UUID列表
     * 通过尝试生成V1, V2, V3...版本的UUID来查找所有历史版本
     * 
     * @param originalUUID 原订单UUID
     * @param maxVersions 最大尝试版本数（防止无限循环）
     * @return 历史版本UUID列表，按版本号升序排列
     */
    public static List<String> getAllHistoryVersions(String originalUUID, int maxVersions) {
        List<String> historyVersions = new ArrayList<>();
        
        if (originalUUID == null || originalUUID.trim().isEmpty()) {
            return historyVersions;
        }
        
        // 从V1开始尝试
        for (int i = 1; i <= maxVersions; i++) {
            String version = "V" + i;
            String versionedUUID = generateVersionedUUID(originalUUID, version);
            historyVersions.add(versionedUUID);
        }
        
        return historyVersions;
    }

    /**
     * 获取指定UUID的所有历史版本UUID列表（默认最大尝试10个版本）
     * 
     * @param originalUUID 原订单UUID
     * @return 历史版本UUID列表
     */
    public static List<String> getAllHistoryVersions(String originalUUID) {
        return getAllHistoryVersions(originalUUID, 10);
    }

    /**
     * 从版本化UUID中提取原UUID
     * 注意：这是一个近似方法，因为UUID v5是单向的
     * 实际使用中建议通过数据库查询来验证
     * 
     * @param versionedUUID 版本化UUID
     * @return 可能的原UUID（需要进一步验证）
     */
    public static String extractOriginalUUID(String versionedUUID) {
        // 由于UUID v5是单向的，无法直接逆向
        // 这里返回null，实际使用中需要通过数据库查询来验证
        return null;
    }

    /**
     * 验证UUID格式是否正确
     * 
     * @param uuid UUID字符串
     * @return 是否为有效的UUID格式
     */
    public static boolean isValidUUID(String uuid) {
        if (uuid == null || uuid.trim().isEmpty()) {
            return false;
        }
        
        try {
            UUID.fromString(uuid.trim());
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    /**
     * 生成新的订单UUID（用于新订单）
     * 
     * @return 新的UUID字符串
     */
    public static String generateNewUUID() {
        return UUID.randomUUID().toString();
    }

    /**
     * 比较两个版本号的大小
     * 
     * @param version1 版本号1
     * @param version2 版本号2
     * @return 比较结果：-1表示version1<version2，0表示相等，1表示version1>version2
     */
    public static int compareVersions(String version1, String version2) {
        if (version1 == null && version2 == null) return 0;
        if (version1 == null) return -1;
        if (version2 == null) return 1;
        
        try {
            String v1 = version1.trim().toUpperCase();
            String v2 = version2.trim().toUpperCase();
            
            if (!v1.startsWith("V") || !v2.startsWith("V")) {
                return version1.compareTo(version2);
            }
            
            int num1 = Integer.parseInt(v1.substring(1));
            int num2 = Integer.parseInt(v2.substring(1));
            
            return Integer.compare(num1, num2);
        } catch (NumberFormatException e) {
            return version1.compareTo(version2);
        }
    }
}
